home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / source / term43-source.lha / Extras / Source / gtlayout-Source.lha / LT_New.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-18  |  33.2 KB  |  1,583 lines
  1. /*  GadTools layout toolkit
  2. **
  3. **  Copyright © 1993-1994 by Olaf `Olsen' Barthel
  4. **  Freely distributable.
  5. */
  6.  
  7. #include "gtlayout_global.h"
  8.  
  9. VOID __stdargs
  10. LT_Add(LayoutHandle *Handle,UBYTE Type,STRPTR Label,LONG ID,...)
  11. {
  12.     va_list VarArgs;
  13.  
  14.     va_start(VarArgs,ID);
  15.     LT_AddA(Handle,Type,Label,ID,(struct TagItem *)VarArgs);
  16.     va_end(VarArgs);
  17. }
  18.  
  19. VOID LIBENT
  20. LT_AddA(REG(a0) LayoutHandle *Handle,REG(d0) UBYTE Type,REG(d1) STRPTR Label,REG(d2) LONG ID,REG(a1) struct TagItem *TagList)
  21. {
  22.     struct TagItem *TagItem;
  23.  
  24.     if(!Handle || Handle -> Failed)
  25.         return;
  26.  
  27.     if(Type == VERTICAL_KIND || Type == HORIZONTAL_KIND || Handle -> TopGroup)
  28.     {
  29.         ObjectNode *Node;
  30.  
  31.         switch(Type)
  32.         {
  33.             case BUTTON_KIND:
  34.  
  35.                 Handle -> IDCMP |= BUTTONIDCMP;
  36.                 break;
  37.  
  38.             case CHECKBOX_KIND:
  39.  
  40.                 Handle -> IDCMP |= CHECKBOXIDCMP;
  41.                 break;
  42.  
  43.             case LISTVIEW_KIND:
  44.  
  45.                 Handle -> IDCMP |= LISTVIEWIDCMP;
  46.                 break;
  47.  
  48.             case MX_KIND:
  49.  
  50.                 Handle -> IDCMP |= MXIDCMP;
  51.                 break;
  52.  
  53.             case CYCLE_KIND:
  54.  
  55.                 Handle -> IDCMP |= CYCLEIDCMP;
  56.                 break;
  57.  
  58.             case PALETTE_KIND:
  59.  
  60.                 Handle -> IDCMP |= PALETTEIDCMP;
  61.                 break;
  62.  
  63.             case SLIDER_KIND:
  64.  
  65.                 Handle -> IDCMP |= SLIDERIDCMP;
  66.                 break;
  67.  
  68.             case SCROLLER_KIND:
  69.  
  70.                 Handle -> IDCMP |= SCROLLERIDCMP | ARROWIDCMP;
  71.                 break;
  72.  
  73.             case INTEGER_KIND:
  74.  
  75.                 Handle -> IDCMP |= STRINGIDCMP | IDCMP_GADGETDOWN | IDCMP_INTUITICKS;
  76.                 break;
  77.  
  78.             case STRING_KIND:
  79.             case FRACTION_KIND:
  80.             case PASSWORD_KIND:
  81.  
  82.                 Handle -> IDCMP |= STRINGIDCMP | IDCMP_GADGETDOWN;
  83.                 break;
  84. #ifdef DO_LEVEL_KIND
  85.             case LEVEL_KIND:
  86.  
  87.                 Handle -> IDCMP |= IDCMP_GADGETDOWN | IDCMP_MOUSEMOVE | IDCMP_GADGETUP;
  88.                 break;
  89. #endif    /* DO_LEVEL_KIND */
  90.             case END_KIND:
  91.  
  92.                 Handle -> CurrentGroup = Handle -> CurrentGroup -> Special . Group . ParentGroup;
  93.                 return;
  94.         }
  95.  
  96.         if(Node = LTP_CreateObjectNode(Handle,Type,ID,Label))
  97.         {
  98.             struct MinList    *ParentList;
  99.             LONG         FirstLabel    = -1;
  100.             LONG         LastLabel    = -1;
  101.             LONG        *LabelTable    = NULL;
  102.  
  103.             Type = Node -> Type;
  104.  
  105.             if(Type == GROUP_KIND)
  106.             {
  107.                 Node -> LabelPlace            = PLACE_IN;
  108.                 Node -> Special . Group . ParentGroup    = Handle -> CurrentGroup;
  109.  
  110.                 if(!Handle -> TopGroup)
  111.                 {
  112.                     Handle -> TopGroup = Node;
  113.  
  114.                     ParentList = NULL;
  115.                 }
  116.                 else
  117.                     ParentList = &Handle -> CurrentGroup -> Special . Group . ObjectList;
  118.  
  119.                 Handle -> CurrentGroup = Node;
  120.  
  121.                 NewList(&Node -> Special . Group . ObjectList);
  122.             }
  123.             else
  124.                 ParentList = &Handle -> CurrentGroup -> Special . Group . ObjectList;
  125.  
  126.             if(Label && !Node -> NoKey)
  127.             {
  128.                 ULONG Len;
  129.  
  130.                 Len = 0;
  131.  
  132.                 while(Label[Len])
  133.                 {
  134.                     if(Label[Len] == '_')
  135.                     {
  136.                         Node -> Key = ToLower(Label[Len + 1]);
  137.  
  138.                         break;
  139.                     }
  140.  
  141.                     Len++;
  142.                 }
  143.             }
  144.  
  145.             if(TagList)
  146.             {
  147.                 struct TagItem *TempList = TagList;
  148.  
  149.                 while(!Handle -> Failed && (TagItem = NextTagItem(&TempList)))
  150.                 {
  151.                     switch(TagItem -> ti_Tag)
  152.                     {
  153.                         case LA_BYTE:
  154.  
  155.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  156.                             Node -> StorageType    = STORAGE_BYTE;
  157.  
  158.                             LTP_GetStorage(Node);
  159.  
  160.                             break;
  161.  
  162.                         case LA_UBYTE:
  163.  
  164.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  165.                             Node -> StorageType    = STORAGE_UBYTE;
  166.  
  167.                             LTP_GetStorage(Node);
  168.  
  169.                             break;
  170.  
  171.                         case LA_WORD:
  172.  
  173.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  174.                             Node -> StorageType    = STORAGE_WORD;
  175.  
  176.                             LTP_GetStorage(Node);
  177.  
  178.                             break;
  179.  
  180.                         case LA_UWORD:
  181.  
  182.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  183.                             Node -> StorageType    = STORAGE_UWORD;
  184.  
  185.                             LTP_GetStorage(Node);
  186.  
  187.                             break;
  188.  
  189.                         case LA_LONG:
  190.  
  191.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  192.                             Node -> StorageType    = STORAGE_LONG;
  193.  
  194.                             LTP_GetStorage(Node);
  195.  
  196.                             break;
  197.  
  198.                         case LA_ULONG:
  199.  
  200.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  201.                             Node -> StorageType    = STORAGE_ULONG;
  202.  
  203.                             LTP_GetStorage(Node);
  204.  
  205.                             break;
  206.  
  207.                         case LA_STRPTR:
  208.  
  209.                             Node -> Storage     = (APTR)TagItem -> ti_Data;
  210.                             Node -> StorageType    = STORAGE_STRPTR;
  211.  
  212.                             LTP_GetStorage(Node);
  213.  
  214.                             break;
  215.  
  216.                         case LAXB_FullSize:
  217.  
  218.                             if(Type == XBAR_KIND || Type == YBAR_KIND)
  219.                                 Node -> Special . Bar . FullSize = TagItem -> ti_Data;
  220.  
  221.                             break;
  222.  
  223.                         case LA_LabelTable:
  224.  
  225.                             LabelTable = (LONG *)TagItem -> ti_Data;
  226.                             break;
  227.  
  228.                         case LA_FirstLabel:
  229.  
  230.                             FirstLabel = TagItem -> ti_Data;
  231.                             break;
  232.  
  233.                         case LA_LastLabel:
  234.  
  235.                             LastLabel = TagItem -> ti_Data;
  236.                             break;
  237.  
  238.                         case LA_LastGadget:
  239.  
  240.                             if(Type == INTEGER_KIND)
  241.                                 Node -> Special . Integer . LastGadget = TagItem -> ti_Data;
  242.                             else
  243.                             {
  244.                                 if(Type == FRACTION_KIND || Type == STRING_KIND || Type == PASSWORD_KIND)
  245.                                     Node -> Special . String . LastGadget = TagItem -> ti_Data;
  246.                             }
  247.  
  248.                             break;
  249.  
  250.                         case LA_LabelChars:
  251.  
  252.                             Node -> LabelChars = TagItem -> ti_Data;
  253.  
  254.                             break;
  255.  
  256.                         case LA_HistoryLines:
  257.  
  258.                             if(Type == INTEGER_KIND)
  259.                                 Node -> Special . Integer . MaxHistoryLines = TagItem -> ti_Data;
  260.                             else
  261.                             {
  262.                                 if(Type == FRACTION_KIND || Type == STRING_KIND || Type == PASSWORD_KIND)
  263.                                     Node -> Special . String . MaxHistoryLines = TagItem -> ti_Data;
  264.                             }
  265.  
  266.                             break;
  267.  
  268.                         case LA_HistoryHook:
  269.  
  270.                             if(Type == INTEGER_KIND)
  271.                                 Node -> Special . Integer . HistoryHook = (struct Hook *)TagItem -> ti_Data;
  272.                             else
  273.                             {
  274.                                 if(Type == FRACTION_KIND || Type == STRING_KIND)
  275.                                     Node -> Special . String . HistoryHook = (struct Hook *)TagItem -> ti_Data;
  276.                             }
  277.  
  278.                             break;
  279.  
  280.                         case LAIN_IncrementerHook:
  281.  
  282.                             if(Type == INTEGER_KIND)
  283.                                 Node -> Special . Integer . IncrementerHook = (struct Hook *)TagItem -> ti_Data;
  284.  
  285.                             break;
  286.  
  287.                         case LA_Min:
  288.  
  289.                             Node -> Min = TagItem -> ti_Data;
  290.  
  291.                             break;
  292.  
  293.                         case LA_Max:
  294.  
  295.                             Node -> Max = TagItem -> ti_Data;
  296.  
  297.                             break;
  298.  
  299.                         case LABX_ReserveSpace:
  300.  
  301.                             if(Type == BOX_KIND)
  302.                                 Node -> Special . Box . ReserveSpace = TagItem -> ti_Data;
  303.  
  304.                             break;
  305.  
  306.                         case LA_Chars:
  307.  
  308.                             Node -> Chars = TagItem -> ti_Data;
  309.  
  310.                             break;
  311.  
  312.                         case LA_LabelPlace:
  313.  
  314.                             Node -> LabelPlace = TagItem -> ti_Data;
  315.  
  316.                             if(Type == MX_KIND)
  317.                             {
  318.                                 if(TagItem -> ti_Data == PLACE_RIGHT)
  319.                                     Node -> LabelPlace = PLACE_RIGHT;
  320.                                 else
  321.                                     Node -> LabelPlace = PLACE_LEFT;
  322.                             }
  323.  
  324.                             break;
  325.  
  326.                         case LA_ExtraSpace:
  327.  
  328.                             Node -> ExtraSpace = (WORD)TagItem -> ti_Data;
  329.  
  330.                             if(Node -> ExtraSpace == 1)
  331.                                 Node -> ExtraSpace = 3;
  332.  
  333.                             break;
  334.  
  335.                         case LA_PageSelector:
  336.  
  337.                             Node -> PageSelector = TagItem -> ti_Data;
  338.                             break;
  339.  
  340.                         case LABT_ExtraFat:
  341.  
  342.                             if(Node -> Type == BUTTON_KIND)
  343.                                 Node -> Special . Button . ExtraFat = TagItem -> ti_Data;
  344.  
  345.                             break;
  346. #ifdef DO_PICKSHORTCUTS
  347.                         case LA_NoKey:
  348.  
  349.                             Node -> NoKey = TagItem -> ti_Data;
  350.                             break;
  351. #endif
  352.                         case LA_HighLabel:
  353.  
  354.                             Node -> HighLabel = TagItem -> ti_Data;
  355.                             break;
  356.  
  357.                         case LAPA_SmallPalette:
  358.  
  359.                             if(Type == PALETTE_KIND)
  360.                                 Node -> Special . Palette . SmallPalette = TagItem -> ti_Data;
  361.  
  362.                             break;
  363.  
  364.                         case LA_Lines:
  365.  
  366.                             if(Type == BOX_KIND)
  367.                             {
  368.                                 LONG Count = TagItem -> ti_Data;
  369.  
  370.                                 if(Node -> Lines != Count)
  371.                                 {
  372.                                     if(Node -> Special . Box . Lines)
  373.                                     {
  374.                                         LTP_Free(Handle,Node -> Special . Box . Lines,sizeof(STRPTR) * Node -> Lines);
  375.  
  376.                                         Node -> Special . Box . Lines = NULL;
  377.                                     }
  378.                                 }
  379.  
  380.                                 if(!Node -> Special . Box . Lines)
  381.                                 {
  382.                                     if(Node -> Special . Box . Lines = (STRPTR *)LTP_Alloc(Handle,sizeof(STRPTR) * Count))
  383.                                     {
  384.                                         LONG i;
  385.  
  386.                                         for(i = 0 ; i < Count ; i++)
  387.                                             Node -> Special . Box . Lines[i] = "";
  388.                                     }
  389.                                     else
  390.                                         Handle -> Failed = TRUE;
  391.                                 }
  392.                             }
  393.  
  394.                             Node -> Lines = TagItem -> ti_Data;
  395.  
  396.                             break;
  397.  
  398.                         case LA_Picker:
  399.  
  400.                             if(Type == TEXT_KIND)
  401.                                 Node -> Special . Text . UsePicker = TagItem -> ti_Data;
  402.  
  403.                             if(Type == STRING_KIND)
  404.                                 Node -> Special . String . UsePicker = TagItem -> ti_Data;
  405.  
  406.                             break;
  407.  
  408.                         case LACY_AutoPageID:
  409.  
  410.                             if(Type == CYCLE_KIND)
  411.                                 Node -> Special . Cycle . AutoPageID = (LONG)TagItem -> ti_Data;
  412.  
  413.                             if(Type == MX_KIND)
  414.                                 Node -> Special . Radio . AutoPageID = (LONG)TagItem -> ti_Data;
  415.  
  416.                             break;
  417.  
  418.                         case LAGR_Spread:
  419.  
  420.                             if(Type == GROUP_KIND)
  421.                                 Node -> Special . Group . Spread = TagItem -> ti_Data;
  422.  
  423.                             break;
  424.  
  425.                         case LAGR_Frame:
  426.  
  427.                             if(Type == GROUP_KIND)
  428.                                 Node -> Special . Group . Frame = TagItem -> ti_Data;
  429.  
  430.                             break;
  431.  
  432.                         case LAGR_SameSize:
  433.  
  434.                             if(Type == GROUP_KIND)
  435.                                 Node -> Special . Group . SameSize = TagItem -> ti_Data;
  436.  
  437.                             break;
  438.  
  439.                         case LAGR_LastAttributes:
  440.  
  441.                             if(Type == GROUP_KIND)
  442.                                 Node -> Special . Group . LastAttributes = TagItem -> ti_Data;
  443.  
  444.                             break;
  445.  
  446.                         case LAGR_ActivePage:
  447.  
  448.                             if(Type == GROUP_KIND)
  449.                             {
  450.                                 Node -> Special . Group . ActivePage    = TagItem -> ti_Data;
  451.                                 Node -> Special . Group . Paging    = TRUE;
  452.                             }
  453.  
  454.                             break;
  455.  
  456.                         case LABT_ReturnKey:
  457.  
  458.                             if(Type == BUTTON_KIND)
  459.                                 Node -> Special . Button . ReturnKey = TagItem -> ti_Data;
  460.  
  461.                             break;
  462.  
  463.                         case LABT_EscKey:
  464.  
  465.                             if(Type == BUTTON_KIND)
  466.                                 Node -> Special . Button . EscKey = TagItem -> ti_Data;
  467.  
  468.                             break;
  469.  
  470.                         case LALV_CursorKey:
  471.  
  472.                             if(Type == LISTVIEW_KIND)
  473.                                 Node -> Special . List . CursorKey = TagItem -> ti_Data;
  474.  
  475.                             break;
  476.  
  477.                         case LALV_LockSize:
  478.  
  479.                             if(Type == LISTVIEW_KIND)
  480.                                 Node -> Special . List . LockSize = TagItem -> ti_Data;
  481.  
  482.                             break;
  483.  
  484.                         case LALV_MaxGrowX:
  485.  
  486.                             if(Type == LISTVIEW_KIND)
  487.                             {
  488.                                 Handle -> GrowView = Node;
  489.  
  490.                                 Node -> Special . List . MaxGrowX = TagItem -> ti_Data;
  491.                             }
  492.  
  493.                             break;
  494.  
  495.                         case LALV_MaxGrowY:
  496.  
  497.                             if(Type == LISTVIEW_KIND)
  498.                             {
  499.                                 Handle -> GrowView = Node;
  500.  
  501.                                 Node -> Special . List . MaxGrowY = TagItem -> ti_Data;
  502.                             }
  503.  
  504.                             break;
  505.  
  506.                         case LALV_ResizeX:
  507.  
  508.                             if(Type == LISTVIEW_KIND)
  509.                             {
  510.                                 Handle -> ResizeView = Node;
  511.  
  512.                                 Handle -> IDCMP |= IDCMP_SIZEVERIFY | IDCMP_NEWSIZE;
  513.  
  514.                                 Node -> Special . List . ResizeX = TagItem -> ti_Data;
  515.                             }
  516.  
  517.                             break;
  518.  
  519.                         case LALV_ResizeY:
  520.  
  521.                             if(Type == LISTVIEW_KIND)
  522.                             {
  523.                                 Handle -> ResizeView = Node;
  524.  
  525.                                 Handle -> IDCMP |= IDCMP_SIZEVERIFY | IDCMP_NEWSIZE;
  526.  
  527.                                 Node -> Special . List . ResizeY = TagItem -> ti_Data;
  528.                             }
  529.  
  530.                             break;
  531.  
  532.                         case LALV_MinChars:
  533.  
  534.                             if(Type == LISTVIEW_KIND)
  535.                                 Node -> Special . List . MinChars = TagItem -> ti_Data;
  536.  
  537.                             break;
  538.  
  539.                         case LALV_MinLines:
  540.  
  541.                             if(Type == LISTVIEW_KIND)
  542.                                 Node -> Special . List . MinLines = TagItem -> ti_Data;
  543.  
  544.                             break;
  545.  
  546.                         case LALV_FlushLabelLeft:
  547.  
  548.                             if(Type == LISTVIEW_KIND)
  549.                                 Node -> Special . List . FlushLabelLeft = TagItem -> ti_Data;
  550.  
  551.                             break;
  552.  
  553.                         case LALV_Labels:
  554.  
  555.                             if(Type == LISTVIEW_KIND)
  556.                             {
  557.                                 STRPTR *Labels = (STRPTR *)TagItem -> ti_Data;
  558.  
  559.                                 if(*Labels)
  560.                                 {
  561.                                     struct List *SomeList;
  562.  
  563.                                     if(SomeList = LTP_Alloc(Handle,sizeof(struct List)))
  564.                                     {
  565.                                         struct Node *SomeNode;
  566.  
  567.                                         NewList(SomeList);
  568.  
  569.                                         Node -> Special . List . Labels = SomeList;
  570.  
  571.                                         while(*Labels)
  572.                                         {
  573.                                             if(SomeNode = LTP_Alloc(Handle,sizeof(struct Node) + strlen(*Labels) + 1))
  574.                                             {
  575.                                                 SomeNode -> ln_Name = (STRPTR)(SomeNode + 1);
  576.  
  577.                                                 strcpy(SomeNode -> ln_Name,*Labels++);
  578.  
  579.                                                 AddTail(SomeList,SomeNode);
  580.                                             }
  581.                                         }
  582.                                     }
  583.                                 }
  584.                             }
  585.  
  586.                             break;
  587.  
  588.                         case LA_Link:
  589.  
  590.                             if(Type == LISTVIEW_KIND)
  591.                                 Node -> Special . List . LinkID = TagItem -> ti_Data;
  592.  
  593.                             if(Type == STRING_KIND || Type == FRACTION_KIND)
  594.                                 Node -> Special . String . LinkID = TagItem -> ti_Data;
  595.  
  596.                             break;
  597.  
  598. #ifdef DO_TAPEDECK_KIND
  599.                         case LATD_ButtonType:
  600.  
  601.                             if(Type == TAPEDECK_KIND)
  602.                                 Node -> Special . TapeDeck . ButtonType = TagItem -> ti_Data;
  603.  
  604.                             break;
  605.  
  606.                         case LATD_Toggle:
  607.  
  608.                             if(Type == TAPEDECK_KIND)
  609.                                 Node -> Special . TapeDeck . Toggle = TagItem -> ti_Data;
  610.  
  611.                             break;
  612.  
  613.                         case LATD_Pressed:
  614.  
  615.                             if(Type == TAPEDECK_KIND)
  616.                                 Node -> Current = TagItem -> ti_Data;
  617.  
  618.                             break;
  619.  
  620.                         case LATD_Smaller:
  621.  
  622.                             if(Type == TAPEDECK_KIND)
  623.                                 Node -> Special . TapeDeck . Smaller = TagItem -> ti_Data;
  624.  
  625.                             break;
  626. #endif    /* DO_TAPEDECK_KIND */
  627.  
  628. #ifdef DO_GAUGE_KIND
  629.                         case LAGA_Percent:
  630.  
  631.                             if(Type == GAUGE_KIND)
  632.                             {
  633.                                 LONG Percent = (LONG)TagItem -> ti_Data;
  634.  
  635.                                 if(Percent <= 0)
  636.                                     Node -> Current = 0;
  637.                                 else
  638.                                 {
  639.                                     if(Percent > 100)
  640.                                         Node -> Current = 100;
  641.                                     else
  642.                                         Node -> Current = Percent;
  643.                                 }
  644.                             }
  645.  
  646.                             break;
  647.  
  648.                         case LAGA_InfoLength:
  649.  
  650.                             if(Type == GAUGE_KIND)
  651.                             {
  652.                                 LONG Length = (LONG)TagItem -> ti_Data;
  653.  
  654.                                 if(Length > Node -> Special . Gauge . InfoLength)
  655.                                 {
  656.                                     STRPTR NewText;
  657.  
  658.                                     if(NewText = (STRPTR)AsmAllocPooled(Handle -> Pool,Length + 1,SysBase))
  659.                                     {
  660.                                         if(Node -> Special . Gauge . InfoText)
  661.                                         {
  662.                                             strcpy(NewText,Node -> Special . Gauge . InfoText);
  663.  
  664.                                             AsmFreePooled(Handle -> Pool,Node -> Special . Gauge . InfoText,Node -> Special . Gauge . InfoLength + 1,SysBase);
  665.                                         }
  666.  
  667.                                         NewText[0] = 0;
  668.  
  669.                                         Node -> Special . Gauge . InfoText    = NewText;
  670.                                         Node -> Special . Gauge . InfoLength    = Length;
  671.                                     }
  672.                                     else
  673.                                         Handle -> Failed = TRUE;
  674.                                 }
  675.                             }
  676.  
  677.                             break;
  678.  
  679.                         case LAGA_InfoText:
  680.  
  681.                             if(Type == GAUGE_KIND)
  682.                             {
  683.                                 STRPTR    SomeText    = (STRPTR)TagItem -> ti_Data;
  684.                                 LONG    Len        = strlen(SomeText);
  685.  
  686.                                 if(!Node -> Special . Gauge . InfoLength)
  687.                                 {
  688.                                     if(Node -> Special . Gauge . InfoText = (STRPTR)AsmAllocPooled(Handle -> Pool,Len + 1,SysBase))
  689.                                         Node -> Special . Gauge . InfoLength = Len;
  690.                                     else
  691.                                         Handle -> Failed = TRUE;
  692.                                 }
  693.  
  694.                                 if(Node -> Special . Gauge . InfoLength)
  695.                                 {
  696.                                     if(Len > Node -> Special . Gauge . InfoLength)
  697.                                         Len = Node -> Special . Gauge . InfoLength;
  698.  
  699.                                     CopyMem(SomeText,Node -> Special . Gauge . InfoText,Len);
  700.  
  701.                                     Node -> Special . Gauge . InfoText[Len] = 0;
  702.                                 }
  703.                             }
  704.  
  705.                             break;
  706. #endif
  707.                         case LALV_ExtraLabels:
  708.  
  709.                             if(Type == LISTVIEW_KIND)
  710.                                 Node -> Special . List . ExtraLabels = (STRPTR *)TagItem -> ti_Data;
  711.  
  712.                             break;
  713.  
  714.                         case LACY_TabKey:
  715.  
  716.                             if(Type == CYCLE_KIND)
  717.                                 Node -> Special . Cycle . TabKey = TagItem -> ti_Data;
  718.  
  719.                             if(Type == MX_KIND)
  720.                                 Node -> Special . Radio . TabKey = TagItem -> ti_Data;
  721.  
  722.                             break;
  723.  
  724.                         case LAFR_RefreshHook:
  725.  
  726.                             if(Type == FRAME_KIND)
  727.                                 Node -> Special . Frame . RefreshHook = (struct Hook *)TagItem -> ti_Data;
  728.  
  729.                             break;
  730.  
  731.                         case LAFR_InnerWidth:
  732.  
  733.                             if(Type == FRAME_KIND)
  734.                                 Node -> Special . Frame . InnerWidth = TagItem -> ti_Data;
  735.  
  736.                             break;
  737.  
  738.                         case LAFR_InnerHeight:
  739.  
  740.                             if(Type == FRAME_KIND)
  741.                                 Node -> Special . Frame . InnerHeight = TagItem -> ti_Data;
  742.  
  743.                             break;
  744.  
  745.                         case LA_DrawBox:
  746.  
  747.                             if(Type == FRAME_KIND)
  748.                                 Node -> Special . Frame . DrawBox = TagItem -> ti_Data;
  749.  
  750.                             if(Type == BOX_KIND)
  751.                                 Node -> Special . Box . DrawBox = TagItem -> ti_Data;
  752.  
  753.                             break;
  754.  
  755.                         case LABX_AlignText:
  756.  
  757.                             if(Type == BOX_KIND)
  758.                                 Node -> Special . Box . AlignText = TagItem -> ti_Data;
  759.  
  760.                             break;
  761.  
  762.                         case LABX_Labels:
  763.  
  764.                             if(Type == BOX_KIND)
  765.                             {
  766.                                 STRPTR    *Labels = (STRPTR *)TagItem -> ti_Data;
  767.                                 LONG     Count    = 0;
  768.  
  769.                                 while(Labels[Count])
  770.                                     Count++;
  771.  
  772.                                 if(Node -> Lines != Count)
  773.                                 {
  774.                                     if(Node -> Special . Box . Lines)
  775.                                     {
  776.                                         LTP_Free(Handle,Node -> Special . Box . Lines,sizeof(STRPTR) * Node -> Lines);
  777.  
  778.                                         Node -> Special . Box . Lines = NULL;
  779.                                     }
  780.                                 }
  781.  
  782.                                 if(Count)
  783.                                 {
  784.                                     if(!Node -> Special . Box . Lines)
  785.                                     {
  786.                                         if(Node -> Special . Box . Lines = LTP_Alloc(Handle,sizeof(STRPTR) * Count))
  787.                                         {
  788.                                             LONG i;
  789.  
  790.                                             for(i = 0 ; i < Count ; i++)
  791.                                                 Node -> Special . Box . Lines[i] = "";
  792.                                         }
  793.                                     }
  794.                                 }
  795.  
  796.                                 Node -> Lines = Count;
  797.  
  798.                                 Node -> Special . Box . Labels = Labels;
  799.                             }
  800.  
  801.                             break;
  802.  
  803.                         case LABX_Lines:
  804.  
  805.                             if(Type == BOX_KIND)
  806.                             {
  807.                                 STRPTR    *Lines = (STRPTR *)TagItem -> ti_Data;
  808.                                 LONG     Count = 0;
  809.  
  810.                                 while(Lines[Count])
  811.                                     Count++;
  812.  
  813.                                 if(Node -> Lines && Count > Node -> Lines)
  814.                                     Count = Node -> Lines;
  815.  
  816.                                 if(Count)
  817.                                 {
  818.                                     if(!Node -> Special . Box . Lines)
  819.                                         Node -> Special . Box . Lines = LTP_Alloc(Handle,sizeof(STRPTR) * Count);
  820.  
  821.                                     if(Node -> Special . Box . Lines)
  822.                                     {
  823.                                         LONG i;
  824.  
  825.                                         for(i = 0 ; i < Count ; i++)
  826.                                             Node -> Special . Box . Lines[i] = Lines[i];
  827.                                     }
  828.                                 }
  829.  
  830.                                 Node -> Lines = Count;
  831.                             }
  832.  
  833.                             break;
  834.  
  835.                         case GA_Disabled:
  836.  
  837.                             Node -> Disabled = TagItem -> ti_Data;
  838.                             break;
  839.  
  840.                         case GTCB_Checked:
  841.  
  842.                             if(Type == CHECKBOX_KIND)
  843.                                 Node -> Current = TagItem -> ti_Data;
  844.  
  845.                             break;
  846.  
  847.                         case GTLV_Labels:
  848.  
  849.                             if(Type == LISTVIEW_KIND)
  850.                                 Node -> Special . List . Labels = (struct List *)TagItem -> ti_Data;
  851.  
  852.                             break;
  853.  
  854.                         case GTLV_ReadOnly:
  855.  
  856.                             if(Type == LISTVIEW_KIND)
  857.                                 Node -> Special . List . ReadOnly = TagItem -> ti_Data;
  858.  
  859.                             break;
  860.  
  861.                         case GTLV_MakeVisible:
  862.                         case GTLV_Selected:
  863.  
  864.                             if(Type == LISTVIEW_KIND)
  865.                                 Node -> Current = (LONG)TagItem -> ti_Data;
  866.  
  867.                             break;
  868.  
  869.                         case GTLV_CallBack:
  870.  
  871.                             if(Type == LISTVIEW_KIND)
  872.                                 Node -> Special . List . CallBack = (struct Hook *)TagItem -> ti_Data;
  873.  
  874.                             break;
  875.  
  876.                         case GTLV_MaxPen:
  877.  
  878.                             if(Type == LISTVIEW_KIND)
  879.                                 Node -> Special . List . MaxPen = TagItem -> ti_Data;
  880.  
  881.                             break;
  882.  
  883.                         case GTMX_Labels:
  884.  
  885.                             if(Type == MX_KIND)
  886.                                 Node -> Special . Radio . Choices = (STRPTR *)TagItem -> ti_Data;
  887.  
  888.                             break;
  889.  
  890.                         case GTMX_Active:
  891.  
  892.                             if(Type == MX_KIND)
  893.                                 Node -> Current = TagItem -> ti_Data;
  894.  
  895.                             break;
  896.  
  897.                         case GTMX_TitlePlace:
  898.  
  899.                             if(Type == MX_KIND && Label)
  900.                             {
  901.                                 if(TagItem -> ti_Data == PLACE_RIGHT)
  902.                                     Node -> Special . Radio . TitlePlace = PLACETEXT_RIGHT;
  903.                                 else
  904.                                     Node -> Special . Radio . TitlePlace = PLACETEXT_LEFT;
  905.                             }
  906.  
  907.                             break;
  908.  
  909.                         case GTTX_Text:
  910.  
  911.                             if(Type == TEXT_KIND)
  912.                                 Node -> Special . Text . Text = (STRPTR)TagItem -> ti_Data;
  913.  
  914.                             break;
  915.  
  916.                         case GTTX_CopyText:
  917.  
  918.                             if(Type == TEXT_KIND)
  919.                                 Node -> Special . Text . CopyText = TagItem -> ti_Data;
  920.  
  921.                             break;
  922.  
  923.                         case GTTX_Border:
  924.  
  925.                             if(Type == TEXT_KIND)
  926.                                 Node -> Special . Text . Border = TagItem -> ti_Data;
  927.  
  928.                             break;
  929.  
  930.                         case GTNM_Number:
  931.  
  932.                             if(Type == NUMBER_KIND)
  933.                                 Node -> Special . Number . Number = TagItem -> ti_Data;
  934.  
  935.                             break;
  936.  
  937.                         case GTNM_Border:
  938.  
  939.                             if(Type == NUMBER_KIND)
  940.                                 Node -> Special . Number . Border = TagItem -> ti_Data;
  941.  
  942.                             break;
  943.  
  944.                         case GTTX_Justification:
  945.  
  946.                             if(Type == NUMBER_KIND)
  947.                                 Node -> Special . Number . Justification = TagItem -> ti_Data;
  948.  
  949.                             if(Type == TEXT_KIND)
  950.                                 Node -> Special . Text . Justification = TagItem -> ti_Data;
  951.  
  952.                             break;
  953.  
  954.                         case GTCY_Labels:
  955.  
  956.                             if(Type == CYCLE_KIND)
  957.                                 Node -> Special . Cycle . Choices = (STRPTR *)TagItem -> ti_Data;
  958.  
  959.                             break;
  960.  
  961.                         case GTCY_Active:
  962.  
  963.                             if(Type == CYCLE_KIND)
  964.                                 Node -> Current = TagItem -> ti_Data;
  965.  
  966.                             break;
  967.  
  968.                         case GTPA_Depth:
  969.  
  970.                             if(Type == PALETTE_KIND)
  971.                             {
  972.                                 Node -> Special . Palette . Depth = TagItem -> ti_Data;
  973.  
  974.                                 if(Handle -> MaxPen < (1L << Node -> Special . Palette . Depth) - 1)
  975.                                     Handle -> MaxPen = (1L << Node -> Special . Palette . Depth) - 1;
  976.                             }
  977.  
  978.                             break;
  979.  
  980.                         case GTPA_Color:
  981.  
  982.                             if(Type == PALETTE_KIND)
  983.                                 Node -> Current = TagItem -> ti_Data;
  984.  
  985.                             break;
  986.  
  987.                         case GTPA_ColorOffset:
  988.  
  989.                             if(Type == PALETTE_KIND)
  990.                                 Node -> Min = TagItem -> ti_Data;
  991.  
  992.                             break;
  993.  
  994.                         case GTPA_NumColors:
  995.  
  996.                             if(Type == PALETTE_KIND)
  997.                             {
  998.                                 Node -> Special . Palette . NumColours = TagItem -> ti_Data;
  999.  
  1000.                                 if(Node -> Special . Palette . ColourTable)
  1001.                                 {
  1002.                                     LONG i;
  1003.  
  1004.                                     for(i = 0 ; i < Node -> Special . Palette . NumColours ; i++)
  1005.                                     {
  1006.                                         if(Node -> Special . Palette . ColourTable[i] > Handle -> MaxPen)
  1007.                                             Handle -> MaxPen = Node -> Special . Palette . ColourTable[i];
  1008.                                     }
  1009.                                 }
  1010.                             }
  1011.  
  1012.                             break;
  1013.  
  1014.                         case GTPA_ColorTable:
  1015.  
  1016.                             if(Type == PALETTE_KIND)
  1017.                             {
  1018.                                 Node -> Special . Palette . ColourTable = (UBYTE *)TagItem -> ti_Data;
  1019.  
  1020.                                 if(Node -> Special . Palette . NumColours)
  1021.                                 {
  1022.                                     LONG i;
  1023.  
  1024.                                     for(i = 0 ; i < Node -> Special . Palette . NumColours ; i++)
  1025.                                     {
  1026.                                         if(Node -> Special . Palette . ColourTable[i] > Handle -> MaxPen)
  1027.                                             Handle -> MaxPen = Node -> Special . Palette . ColourTable[i];
  1028.                                     }
  1029.                                 }
  1030.                             }
  1031.  
  1032.                             break;
  1033.  
  1034.                         case GTSC_Top:
  1035.  
  1036.                             if(Type == SCROLLER_KIND)
  1037.                                 Node -> Current = TagItem -> ti_Data;
  1038.  
  1039.                             break;
  1040.  
  1041.                         case GTSC_Total:
  1042.  
  1043.                             if(Type == SCROLLER_KIND)
  1044.                                 Node -> Max = TagItem -> ti_Data;
  1045.  
  1046.                             break;
  1047.  
  1048.                         case GTSC_Visible:
  1049.  
  1050.                             if(Type == SCROLLER_KIND)
  1051.                                 Node -> Special . Scroller . Visible = TagItem -> ti_Data;
  1052.  
  1053.                             break;
  1054.  
  1055.                         case GTSC_Arrows:
  1056.  
  1057.                             if(Type == SCROLLER_KIND)
  1058.                                 Node -> Special . Scroller . Arrows = (TagItem -> ti_Data != 0);
  1059.  
  1060.                             break;
  1061.  
  1062.                         case LASC_Thin:
  1063.  
  1064.                             if(Type == SCROLLER_KIND)
  1065.                                 Node -> Special . Scroller . Thin = TagItem -> ti_Data;
  1066.  
  1067.                             break;
  1068.  
  1069.                         case PGA_Freedom:
  1070.  
  1071.                             if(Type == SCROLLER_KIND)
  1072.                                 Node -> Special . Scroller . Vertical = (TagItem -> ti_Data == LORIENT_VERT);
  1073.  
  1074.                             break;
  1075.  
  1076.                         case GTSL_Min:
  1077.  
  1078. #ifdef DO_LEVEL_KIND
  1079.                             if(Type == LEVEL_KIND)
  1080.                                 Node -> Special . Level . Min = (LONG)TagItem -> ti_Data;
  1081. #endif    /* DO_LEVEL_KIND */
  1082.                             if(Type == SLIDER_KIND)
  1083.                                 Node -> Min = TagItem -> ti_Data;
  1084.  
  1085.                             break;
  1086.  
  1087.                         case GTSL_Max:
  1088.  
  1089. #ifdef DO_LEVEL_KIND
  1090.                             if(Type == LEVEL_KIND)
  1091.                                 Node -> Special . Level . Max = (LONG)TagItem -> ti_Data;
  1092. #endif    /* DO_LEVEL_KIND */
  1093.                             if(Type == SLIDER_KIND)
  1094.                                 Node -> Max = TagItem -> ti_Data;
  1095.  
  1096.                             break;
  1097.  
  1098.                         case GTSL_Level:
  1099.  
  1100. #ifdef DO_LEVEL_KIND
  1101.                             if(Type == LEVEL_KIND)
  1102.                                 Node -> Special . Level . Level = (LONG)TagItem -> ti_Data;
  1103. #endif    /* DO_LEVEL_KIND */
  1104.                             if(Type == SLIDER_KIND)
  1105.                                 Node -> Current = TagItem -> ti_Data;
  1106.  
  1107.                             break;
  1108.  
  1109.                         case GTSL_LevelFormat:
  1110.  
  1111. #ifdef DO_LEVEL_KIND
  1112.                             if(Type == LEVEL_KIND)
  1113.                                 Node -> Special . Level . LevelFormat = (STRPTR)TagItem -> ti_Data;
  1114. #endif    /* DO_LEVEL_KIND */
  1115.                             if(Type == SLIDER_KIND)
  1116.                                 Node -> Special . Slider . LevelFormat = (STRPTR)TagItem -> ti_Data;
  1117.  
  1118.                             break;
  1119.  
  1120.                         case GTSL_LevelPlace:
  1121.  
  1122. #ifdef DO_LEVEL_KIND
  1123.                             if(Type == LEVEL_KIND)
  1124.                             {
  1125.                                 if(TagItem -> ti_Data == PLACE_RIGHT)
  1126.                                     Node -> Special . Level . LevelPlace = PLACETEXT_RIGHT;
  1127.                                 else
  1128.                                     Node -> Special . Level . LevelPlace = PLACETEXT_LEFT;
  1129.                             }
  1130. #endif    /* DO_LEVEL_KIND */
  1131.                             if(Type == SLIDER_KIND)
  1132.                             {
  1133.                                 if(TagItem -> ti_Data == PLACE_RIGHT)
  1134.                                     Node -> Special . Slider . LevelPlace = PLACETEXT_RIGHT;
  1135.                                 else
  1136.                                     Node -> Special . Slider . LevelPlace = PLACETEXT_LEFT;
  1137.                             }
  1138.  
  1139.                             break;
  1140.  
  1141.                         case GTSL_DispFunc:
  1142.  
  1143. #ifdef DO_LEVEL_KIND
  1144.                             if(Type == LEVEL_KIND)
  1145.                                 Node -> Special . Level . DispFunc = (DISPFUNC)TagItem -> ti_Data;
  1146. #endif    /* DO_LEVEL_KIND */
  1147.                             if(Type == SLIDER_KIND)
  1148.                                 Node -> Special . Slider . DispFunc = (DISPFUNC)TagItem -> ti_Data;
  1149.  
  1150.                             break;
  1151.  
  1152.                         case LASL_FullCheck:
  1153.  
  1154.                             if(Type == SLIDER_KIND)
  1155.                                 Node -> Special . Slider . FullLevelCheck = TagItem -> ti_Data;
  1156.  
  1157. #ifdef DO_LEVEL_KIND
  1158.                             if(Type == LEVEL_KIND)
  1159.                                 Node -> Special . Level . FullLevelCheck = TagItem -> ti_Data;
  1160. #endif    /* DO_LEVEL_KIND */
  1161.                             break;
  1162.  
  1163.                         case GTST_String:
  1164.  
  1165.                             if(Type == STRING_KIND || Type == PASSWORD_KIND)
  1166.                                 Node -> Special . String . String = (STRPTR)TagItem -> ti_Data;
  1167.  
  1168.                             break;
  1169.  
  1170.                         case GTST_MaxChars:
  1171.  
  1172.                             if(Type == STRING_KIND || Type == PASSWORD_KIND)
  1173.                                 Node -> Special . String . MaxChars = TagItem -> ti_Data;
  1174.  
  1175.                             break;
  1176.  
  1177.                         case GTST_EditHook:
  1178.  
  1179.                             if(Type == STRING_KIND)
  1180.                                 Node -> Special . String . EditHook = (struct Hook *)TagItem -> ti_Data;
  1181.                             else
  1182.                             {
  1183.                                 if(Type == INTEGER_KIND)
  1184.                                     Node -> Special . Integer . EditHook = (struct Hook *)TagItem -> ti_Data;
  1185.                             }
  1186.  
  1187.                             break;
  1188.  
  1189.                         case STRINGA_Justification:
  1190.  
  1191.                             if(Type == STRING_KIND || Type == FRACTION_KIND || Type == PASSWORD_KIND)
  1192.                                 Node -> Special . String . Justification = TagItem -> ti_Data;
  1193.                             else
  1194.                             {
  1195.                                 if(Type == INTEGER_KIND)
  1196.                                     Node -> Special . Integer . Justification = TagItem -> ti_Data;
  1197.                             }
  1198.  
  1199.                             break;
  1200. #ifdef DO_FRACTION_KIND
  1201.                         case LAFC_MaxChars:
  1202.  
  1203.                             if(Type == FRACTION_KIND)
  1204.                                 Node -> Special . String . MaxChars = TagItem -> ti_Data;
  1205.  
  1206.                             break;
  1207.  
  1208.                         case LAFC_Number:
  1209.  
  1210.                             if(Type == FRACTION_KIND)
  1211.                                 Node -> Current = TagItem -> ti_Data;
  1212.  
  1213.                             break;
  1214. #endif
  1215.                         case LAIN_UseIncrementers:
  1216.  
  1217.                             if(Type == INTEGER_KIND)
  1218.                             {
  1219.                                 if(Node -> Special . Integer . UseIncrementers = TagItem -> ti_Data)
  1220.                                     Handle -> IDCMP |= IDCMP_INTUITICKS;
  1221.                             }
  1222.  
  1223.                             break;
  1224.  
  1225.                         case GTIN_Number:
  1226.  
  1227.                             if(Type == INTEGER_KIND)
  1228.                                 Node -> Special . Integer . Number = TagItem -> ti_Data;
  1229.  
  1230.                             break;
  1231.  
  1232.                         case GTIN_MaxChars:
  1233.  
  1234.                             if(Type == INTEGER_KIND)
  1235.                                 Node -> Special . Integer . MaxChars = TagItem -> ti_Data;
  1236.  
  1237.                             break;
  1238.                     }
  1239.                 }
  1240.             }
  1241.  
  1242.             if(Handle -> Failed)
  1243.                 return;
  1244.  
  1245.             if((Type == FRACTION_KIND || Type == STRING_KIND || Type == INTEGER_KIND) && Node -> Special . String . MaxHistoryLines)
  1246.             {
  1247.                 if(!Node -> Special . Integer . HistoryHook)
  1248.                 {
  1249.                     struct Hook *Hook;
  1250.  
  1251.                     if(Hook = (struct Hook *)LTP_Alloc(Handle,sizeof(struct Hook) + sizeof(struct MinList)))
  1252.                     {
  1253.                         struct MinList *List;
  1254.  
  1255.                         List = Hook -> h_Data = (APTR)(Hook + 1);
  1256.  
  1257.                         NewList((struct List *)List);
  1258.  
  1259.                         Hook -> h_Entry = (HOOKFUNC)LTP_DefaultHistoryHook;
  1260.  
  1261.                         Node -> Special . Integer . HistoryHook = Hook;
  1262.                     }
  1263.                 }
  1264.  
  1265.                 if(Node -> Special . Integer . HistoryHook)
  1266.                 {
  1267.                     struct Node    *TextNode;
  1268.                     struct MinList    *List = (struct List *)Node -> Special . Integer . HistoryHook -> h_Data;
  1269.  
  1270.                     Node -> Special . Integer . LayoutHandle    = Handle;
  1271.                     Node -> Special . Integer . NumHistoryLines    = 0;
  1272.  
  1273.                     TextNode = (struct Node *)List -> mlh_Head;
  1274.  
  1275.                     while(TextNode -> ln_Succ)
  1276.                     {
  1277.                         Node -> Special . Integer . NumHistoryLines++;
  1278.  
  1279.                         TextNode = TextNode -> ln_Succ;
  1280.                     }
  1281.                 }
  1282.             }
  1283.  
  1284.             if(Type == TEXT_KIND && Node -> Special . Text . CopyText && Node -> Special . Text . Text)
  1285.             {
  1286.                 LONG    len;
  1287.                 STRPTR    text;
  1288.  
  1289.                 len = strlen(Node -> Special . Text . Text);
  1290.  
  1291.                 if(text = LTP_Alloc(Handle,len + 1))
  1292.                 {
  1293.                     strcpy(text,Node -> Special . Text . Text);
  1294.  
  1295.                     Node -> Special . Text . Text = text;
  1296.                 }
  1297.             }
  1298.  
  1299.             if((FirstLabel != -1 && LastLabel != -1) || LabelTable)
  1300.             {
  1301.                 if(Type == MX_KIND || Type == CYCLE_KIND || Type == LISTVIEW_KIND || Type == BOX_KIND)
  1302.                 {
  1303.                     if(!Handle -> LocaleHook)
  1304.                         Handle -> Failed = TRUE;
  1305.                     else
  1306.                     {
  1307.                         if(Type == LISTVIEW_KIND)
  1308.                         {
  1309.                             struct List *SomeList;
  1310.  
  1311.                             if(SomeList = (struct List *)LTP_Alloc(Handle,sizeof(struct List)))
  1312.                             {
  1313.                                 struct Node    *SomeNode;
  1314.                                 LONG         Count = (LastLabel - FirstLabel + 1),i;
  1315.  
  1316.                                 NewList(SomeList);
  1317.  
  1318.                                 Node -> Special . List . Labels = SomeList;
  1319.  
  1320.                                 if(LabelTable)
  1321.                                 {
  1322.                                     while(*LabelTable != -1)
  1323.                                     {
  1324.                                         if(SomeNode = LTP_Alloc(Handle,sizeof(struct Node)))
  1325.                                         {
  1326.                                             SomeNode -> ln_Name = (STRPTR)CallHookPkt(Handle -> LocaleHook,Handle,(APTR)(*LabelTable++));
  1327.  
  1328.                                             AddTail(SomeList,SomeNode);
  1329.                                         }
  1330.                                     }
  1331.                                 }
  1332.                                 else
  1333.                                 {
  1334.                                     for(i = 0 ; i < Count ; i++)
  1335.                                     {
  1336.                                         if(SomeNode = LTP_Alloc(Handle,sizeof(struct Node)))
  1337.                                         {
  1338.                                             SomeNode -> ln_Name = (STRPTR)CallHookPkt(Handle -> LocaleHook,Handle,(APTR)(FirstLabel + i));
  1339.  
  1340.                                             AddTail(SomeList,SomeNode);
  1341.                                         }
  1342.                                     }
  1343.                                 }
  1344.                             }
  1345.                         }
  1346.                         else
  1347.                         {
  1348.                             STRPTR    *Labels;
  1349.                             LONG     Count = (LastLabel - FirstLabel + 1),i;
  1350.  
  1351.                             if(LabelTable)
  1352.                             {
  1353.                                 register LONG *Index = LabelTable;
  1354.  
  1355.                                 for(Count = 0 ; *Index != -1 ; Count++, Index++);
  1356.                             }
  1357.  
  1358.                             if(Labels = LTP_Alloc(Handle,sizeof(STRPTR) * (Count + 1)))
  1359.                             {
  1360.                                 if(LabelTable)
  1361.                                 {
  1362.                                     for(i = 0 ; i < Count ; i++)
  1363.                                         Labels[i] = (STRPTR)CallHookPkt(Handle -> LocaleHook,Handle,(APTR)(*LabelTable++));
  1364.                                 }
  1365.                                 else
  1366.                                 {
  1367.                                     for(i = 0 ; i < Count ; i++)
  1368.                                         Labels[i] = (STRPTR)CallHookPkt(Handle -> LocaleHook,Handle,(APTR)(FirstLabel + i));
  1369.                                 }
  1370.  
  1371.                                 Labels[i] = NULL;
  1372.  
  1373.                                 if(Type == MX_KIND)
  1374.                                     Node -> Special . Radio . Choices = Labels;
  1375.                                 else
  1376.                                 {
  1377.                                     if(Type == CYCLE_KIND)
  1378.                                         Node -> Special . Cycle . Choices = Labels;
  1379.                                     else
  1380.                                     {
  1381.                                         if(Type == BOX_KIND)
  1382.                                         {
  1383.                                             if(!Node -> Special . Box . Lines)
  1384.                                             {
  1385.                                                 if(Node -> Special . Box . Lines = LTP_Alloc(Handle,sizeof(STRPTR) * Count))
  1386.                                                 {
  1387.                                                     LONG i;
  1388.  
  1389.                                                     for(i = 0 ; i < Count ; i++)
  1390.                                                         Node -> Special . Box . Lines[i] = "";
  1391.                                                 }
  1392.                                             }
  1393.  
  1394.                                             Node -> Lines = Count;
  1395.  
  1396.                                             Node -> Special . Box . Labels = Labels;
  1397.                                         }
  1398.                                     }
  1399.                                 }
  1400.                             }
  1401.                         }
  1402.                     }
  1403.                 }
  1404.             }
  1405.  
  1406.             if(Type == BOX_KIND && Node -> Special . Box . ReserveSpace)
  1407.             {
  1408.                 LONG    Size;
  1409.                 STRPTR    Buffer;
  1410.  
  1411.                 if(!Node -> Special . Box . Lines)
  1412.                 {
  1413.                     if(Node -> Special . Box . Lines = LTP_Alloc(Handle,sizeof(STRPTR) * Node -> Lines))
  1414.                     {
  1415.                         LONG i;
  1416.  
  1417.                         for(i = 0 ; i < Node -> Lines ; i++)
  1418.                             Node -> Special . Box . Lines[i] = "";
  1419.                     }
  1420.                 }
  1421.  
  1422.                 if(!Node -> Chars)
  1423.                     Size = 10;
  1424.                 else
  1425.                     Size = Node -> Chars;
  1426.  
  1427.                 Node -> Special . Box . MaxSize = Size;
  1428.  
  1429.                 if(Buffer = (STRPTR)LTP_Alloc(Handle,(Size + 1) * Node -> Lines))
  1430.                 {
  1431.                     LONG i,Len;
  1432.  
  1433.                     for(i = 0 ; i < Node -> Lines ; i++)
  1434.                     {
  1435.                         if(Node -> Special . Box . Lines[i])
  1436.                         {
  1437.                             Len = strlen(Node -> Special . Box . Lines[i]);
  1438.  
  1439.                             if(Len > Size)
  1440.                                 Len = Size;
  1441.  
  1442.                             CopyMem(Node -> Special . Box . Lines[i],Buffer,Len);
  1443.  
  1444.                             Buffer[Len] = 0;
  1445.                         }
  1446.                         else
  1447.                             Buffer[0] = 0;
  1448.  
  1449.                         Node -> Special . Box . Lines[i] = Buffer;
  1450.  
  1451.                         Buffer += Size + 1;
  1452.                     }
  1453.                 }
  1454.             }
  1455.  
  1456.             if(Handle -> Failed)
  1457.                 return;
  1458.  
  1459.             if(ParentList)
  1460.             {
  1461. #ifdef DO_PASSWORD_KIND
  1462.                 if(Type == PASSWORD_KIND)
  1463.                 {
  1464.                     STRPTR Buffer;
  1465.  
  1466.                     if(!(Buffer = LTP_Alloc(Handle,2 * (Node -> Special . String . MaxChars + 1))))
  1467.                         return;
  1468.  
  1469.                     Node -> Special . String . RealString    = Buffer;
  1470.                     Node -> Special . String . Original    = Buffer + Node -> Special . String . MaxChars + 1;
  1471.  
  1472.                     if(Node -> Special . String . String)
  1473.                     {
  1474.                         strcpy(Node -> Special . String . RealString,    Node -> Special . String . String);
  1475.                         strcpy(Node -> Special . String . Original,    Node -> Special . String . String);
  1476.                     }
  1477.                 }
  1478. #endif
  1479.                 AddTail((struct List *)ParentList,(struct Node *)Node);
  1480.  
  1481.                 if(Type == XBAR_KIND || Type == YBAR_KIND)
  1482.                     Node -> Special . Bar . Parent = Handle -> CurrentGroup;
  1483.             }
  1484.         }
  1485.     }
  1486. }
  1487.  
  1488.  
  1489. /*****************************************************************************/
  1490.  
  1491.  
  1492. VOID __stdargs
  1493. LT_AddL(LayoutHandle *handle,UBYTE type,ULONG labelID,LONG id,...)
  1494. {
  1495.     if(handle)
  1496.     {
  1497.         struct TagItem    *tagList;
  1498.         va_list      varArg;
  1499.  
  1500.         va_start(varArg,id);
  1501.  
  1502.         tagList = (struct TagItem *)varArg;
  1503.  
  1504.         if(handle -> LocaleHook)
  1505.         {
  1506.             STRPTR label;
  1507.  
  1508.             label = (STRPTR)CallHookPkt(handle -> LocaleHook,handle,(APTR)labelID);
  1509.  
  1510.             LT_AddA(handle,type,label,id,tagList);
  1511.         }
  1512.         else
  1513.             handle -> Failed = TRUE;
  1514.  
  1515.         va_end(varArgs);
  1516.     }
  1517. }
  1518.  
  1519.  
  1520. /*****************************************************************************/
  1521.  
  1522.  
  1523. VOID __stdargs
  1524. LT_New(LayoutHandle *handle,...)
  1525. {
  1526.     va_list VarArgs;
  1527.  
  1528.     va_start(VarArgs,handle);
  1529.     LT_NewA(handle,(struct TagItem *)VarArgs);
  1530.     va_end(VarArgs);
  1531. }
  1532.  
  1533. VOID LIBENT
  1534. LT_NewA(REG(a0) LayoutHandle *handle,REG(a1) struct TagItem *tagList)
  1535. {
  1536.     if(handle)
  1537.     {
  1538.         struct TagItem    *tag;
  1539.         UBYTE         type;
  1540.         STRPTR         label;
  1541.         ULONG         id;
  1542.  
  1543.         if(tag = FindTagItem(LA_Type,tagList))
  1544.         {
  1545.             type = tag -> ti_Data;
  1546.  
  1547.             if(type == END_KIND)
  1548.             {
  1549.                 handle -> CurrentGroup = handle -> CurrentGroup -> Special . Group . ParentGroup;
  1550.  
  1551.                 return;
  1552.             }
  1553.  
  1554.             if(tag = FindTagItem(LA_ID,tagList))
  1555.                 id = tag -> ti_Data;
  1556.  
  1557.             if(tag = FindTagItem(LA_LabelID,tagList))
  1558.             {
  1559.                 if(handle -> LocaleHook)
  1560.                     label = (STRPTR)CallHookPkt(handle -> LocaleHook,handle,(APTR)tag -> ti_Data);
  1561.                 else
  1562.                     handle -> Failed = TRUE;
  1563.             }
  1564.             else
  1565.                 label = (STRPTR)GetTagData(LA_LabelText,NULL,tagList);
  1566.  
  1567.             LT_AddA(handle,type,label,id,tagList);
  1568.         }
  1569.         else
  1570.             handle -> Failed = TRUE;
  1571.     }
  1572. }
  1573.  
  1574.  
  1575. /*****************************************************************************/
  1576.  
  1577.  
  1578. VOID LIBENT
  1579. LT_EndGroup(REG(a0) LayoutHandle *handle)
  1580. {
  1581.     LT_AddA(handle,END_KIND,NULL,0,NULL);
  1582. }
  1583.